package modifier;

//public类可以被其他包访问
public class ModifierDemo {
    // public修饰符：所有类可见
    public String publicField = "我是public字段";

    // private修饰符：仅本类可见
    private String privateField = "我是private字段";

    // protected修饰符：本类、同包类、子类可见
    protected String protectedField = "我是protected字段";

    // 默认修饰符（包访问权限）：本类和同包类可见
    String defaultField = "我是默认字段";

    // static修饰符：属于类，不属于实例
    public static String staticField = "我是静态字段";

    // final修饰符：值不能被修改
    public final String finalField = "我是常量字段";

    // 静态方法：可以通过类名直接调用
    public static void staticMethod() {
        System.out.println("这是静态方法");
        // 静态方法中不能直接访问非静态成员
        // System.out.println(publicField); // 编译错误
    }

    // private方法：仅本类可调用
    private void privateMethod() {
        System.out.println("这是private方法");
    }

    // public方法：所有类可调用
    public void publicMethod() {
        // 本类中可以访问所有修饰符的成员
        System.out.println(privateField);
        System.out.println(protectedField);
        System.out.println(defaultField);

        // 调用private方法
        privateMethod();
    }

    // final方法：不能被重写
    public final void finalMethod() {
        System.out.println("这是final方法，不能被重写");
    }

    public static void main(String[] args) {
        ModifierDemo demo = new ModifierDemo();

        // 访问public成员
        System.out.println(demo.publicField);

        // 访问private成员会编译错误
        // System.out.println(demo.privateField);

        // 访问protected成员（本类中可以）
        System.out.println(demo.protectedField);

        // 访问默认修饰符成员（本类中可以）
        System.out.println(demo.defaultField);

        // 访问静态成员
        System.out.println(ModifierDemo.staticField);
        ModifierDemo.staticMethod();

        // 调用public方法
        demo.publicMethod();
    }
}

// final类：不能被继承
final class FinalClass {
    // 类内容
}

// abstract类：可以包含抽象方法，不能实例化
abstract class AbstractClass {
    // abstract方法：没有实现，必须在子类中重写
    public abstract void abstractMethod();

    // 普通方法
    public void concreteMethod() {
        System.out.println("这是抽象类中的具体方法");
    }
}

// 继承抽象类必须实现其抽象方法
class ConcreteClass extends AbstractClass {
    @Override
    public void abstractMethod() {
        System.out.println("实现抽象方法");
    }

    // 尝试重写final方法会编译错误
    // @Override
    // public void finalMethod() {}
}

// 同包下的类可以访问默认修饰符和protected成员
class SamePackageClass {
    public void accessDemo() {
        ModifierDemo demo = new ModifierDemo();
        System.out.println(demo.defaultField);      // 可以访问默认修饰符成员
        System.out.println(demo.protectedField);   // 可以访问protected成员
        System.out.println(demo.publicField);      // 可以访问public成员
        // System.out.println(demo.privateField);  // 不能访问private成员
    }
}